home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 22 / Cream of the Crop 22.iso / os2 / ext2_200.zip / EXT2_SRC.ZIP / 32BITS / EXT2-OS2 / FSD32 / FS32_CHD.C < prev    next >
C/C++ Source or Header  |  1996-09-21  |  6KB  |  182 lines
  1. //
  2. // $Header: D:/32bits/ext2-os2/fsd32/RCS/fs32_chdir.c,v 1.1 1996/09/21 22:24:00 Willm Exp Willm $
  3. //
  4.  
  5. // 32 bits Linux ext2 file system driver for OS/2 WARP - Allows OS/2 to
  6. // access your Linux ext2fs partitions as normal drive letters.
  7. // Copyright (C) 1995, 1996 Matthieu WILLM
  8. //
  9. // This program is free software; you can redistribute it and/or modify
  10. // it under the terms of the GNU General Public License as published by
  11. // the Free Software Foundation; either version 2 of the License, or
  12. // (at your option) any later version.
  13. //
  14. // This program is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17. // GNU General Public License for more details.
  18. //
  19. // You should have received a copy of the GNU General Public License
  20. // along with this program; if not, write to the Free Software
  21. // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22. #ifdef __IBMC__
  23. #pragma strings(readonly)
  24. #endif
  25.  
  26.  
  27. #define INCL_DOS
  28. #define INCL_DOSERRORS
  29. #define INCL_NOPMAPI
  30. #include <os2.h>
  31.  
  32. #include <os2/types.h>
  33. #include <os2/StackToFlat.h>
  34. #include <os2/fsd32.h>
  35. #include <os2/fsh32.h>
  36. #include <os2/DevHlp32.h>
  37.  
  38. #include <linux/stat.h>
  39.  
  40. #include <os2/os2proto.h>
  41. #include <os2/ifsdbg.h>
  42. #include <os2/filefind.h>
  43. #include <os2/errors.h>
  44. #include <os2/log.h>         /* Prototypes des fonctions de log.c                      */
  45. #include <os2/volume.h>      /* Prototypes des fonctions de volume.c                   */
  46. #include <os2/files.h>       /* Prototypes des fonctions de files.c                    */
  47. #include <os2/os2misc.h>
  48. #include <os2/trace.h>
  49.  
  50. #include <linux/fs.h>
  51. #include <linux/fs_proto.h>
  52. #include <linux/ext2_fs.h>
  53. #include <linux/ext2_proto.h>
  54. #include <linux/sched.h>
  55.  
  56. #define THISFILE FILE_FS_DIR_C
  57.  
  58. /*
  59.  * struct fs32_chdir_parms {
  60.  *     unsigned short      iCurDirEnd;
  61.  *     PTR16               pDir;
  62.  *     PTR16               pcdfsd;
  63.  *     PTR16               pcdfsi;
  64.  *     unsigned short      flag;
  65.  * };
  66.  */
  67. int FS32ENTRY fs32_chdir(struct fs32_chdir_parms *parms) {
  68.     char           *pDir;
  69.     struct cdfsi32 *pcdfsi;
  70.     union  cdfsd32 *pcdfsd;
  71.     int             rc;
  72.     int             DOSmode;
  73.     struct file        *p_file;
  74.     struct super_block *p_volume;
  75.     int                 valid;
  76.  
  77.     parms = __StackToFlat(parms);
  78.  
  79.     if ((rc = DevHlp32_VirtToLin(parms->pcdfsd, __StackToFlat(&pcdfsd))) == NO_ERROR) {
  80.  
  81.  
  82.     DOSmode = (is_case_retensive() ? OPENMODE_DOSBOX : 0);
  83.  
  84.     switch(parms->flag) {
  85.         case CD_EXPLICIT :
  86.             if ((rc = DevHlp32_VirtToLin(parms->pDir, __StackToFlat(&pDir))) == NO_ERROR) {
  87.                 if ((rc = DevHlp32_VirtToLin(parms->pcdfsi, __StackToFlat(&pcdfsi))) == NO_ERROR) {
  88.             if (trace_FS_CHDIR) {
  89.                 kernel_printf("FS_CHDIR( CD_EXPLICIT, %s )", pDir);
  90.             }
  91.  
  92.             if (parms->iCurDirEnd != ~0) {
  93.                 kernel_printf("\tOld CDS is %s", pcdfsi->cdi_curdir);
  94.             }
  95.  
  96.             //
  97.             // Gets the superblock from pcdfsi
  98.             //
  99.             p_volume = getvolume(pcdfsi->cdi_hVPB);
  100.  
  101.             if ((p_file = _open_by_name(p_volume, pDir, OPENMODE_READONLY | DOSmode)) == 0) {
  102.                 fs_err(FUNC_FS_CHDIR, FUNC_OPEN_BY_NAME, ERROR_PATH_NOT_FOUND, THISFILE, __LINE__);
  103.                 return ERROR_PATH_NOT_FOUND;
  104.             } else {
  105.                 if (!S_ISDIR(p_file->f_inode->i_mode)) {
  106.                     kernel_printf("FS_CHDIR( %s ) Not a directory", pDir);
  107.                     vfs_close(p_file);
  108.                     return ERROR_ACCESS_DENIED;
  109.                 }
  110.                 pcdfsd->u.is_valid = 1;
  111.                 pcdfsd->u.p_file   = p_file;
  112.  
  113.                 return NO_ERROR;
  114.             } /* end if */
  115.                 }
  116.             }
  117.             break;
  118.  
  119.         case CD_VERIFY   :
  120.             if ((rc = DevHlp32_VirtToLin(parms->pcdfsi, __StackToFlat(&pcdfsi))) == NO_ERROR) {
  121.             if (trace_FS_CHDIR) {
  122.                 kernel_printf("FS_CHDIR : flag = CD_VERIFY hVPB=0x%04X", pcdfsi->cdi_hVPB);
  123.             }
  124.  
  125.             //
  126.             // Gets the superblock from pcdfsi
  127.             //
  128.             p_volume = getvolume(pcdfsi->cdi_hVPB);
  129.             kernel_printf("\tsb->s_status = %d",p_volume->s_status);
  130.             valid    = 1;
  131.             if ((p_file = _open_by_name(p_volume, pcdfsi->cdi_curdir, OPENMODE_READONLY | DOSmode)) == 0) {
  132.                 fs_err(FUNC_FS_CHDIR, FUNC_OPEN_BY_NAME, ERROR_PATH_NOT_FOUND, THISFILE, __LINE__);
  133.                 valid = 0;
  134.             } else {
  135.             if (!S_ISDIR(p_file->f_inode->i_mode)) {
  136.                 kernel_printf("FS_CHDIR( %s ) Not a directory", pDir);
  137.                 vfs_close(p_file);
  138.                 valid = 0;
  139.             }
  140.  
  141.             if (pcdfsi->cdi_flags & CDI_ISVALID) {
  142.                 vfs_close(pcdfsd->u.p_file);
  143.             }
  144.             if (valid) {
  145.                 pcdfsd->u.is_valid = 1;
  146.                 pcdfsd->u.p_file   = p_file;
  147.                 return NO_ERROR;
  148.             } else {
  149.                 vfs_close(p_file);
  150.                 return ERROR_PATH_NOT_FOUND;
  151.             }
  152.             }
  153.             }
  154.             break;
  155.  
  156.         case CD_FREE :
  157.             if (trace_FS_CHDIR) {
  158.                 kernel_printf("FS_CHDIR( CD_FREE )");
  159.             }
  160.  
  161.  
  162.             if (pcdfsd->u.is_valid == 1) {
  163.                 pcdfsd->u.is_valid = 0;
  164.                 if ((rc = vfs_close(pcdfsd->u.p_file)) != NO_ERROR) {
  165.                     fs_err(FUNC_FS_CHDIR, FUNC_CLOSE, rc, THISFILE, __LINE__);
  166.                 }
  167. //                return rc;
  168.             } else {
  169.                 rc = NO_ERROR;
  170.             }
  171.             break;
  172.  
  173.         default :
  174.             fs_log("FS_CHDIR : invalid flag");
  175.             rc = ERROR_INVALID_PARAMETER;
  176.  
  177.     }
  178.  
  179.     }
  180.     return rc;
  181. }
  182.